using Godot;
using System;
using Smr.枚举;
using Smr.基类;
using Smr.索引;
using Smr;
using System.Collections.Generic;

public partial class 装备重组 : PanelContainer
{
    [Export] private 组件道具选项垂直容器 道具选项容器;
    [Export] private 组件道具 操作道具组件;
    [Export] private Label 操作道具标签;
    [Export] private Label[] 附加属性标签;
    [Export] private 组件道具[] 拆分道具组;
    [Export] private Button 重组按钮;
    [Export] private Label 消耗标题标签;
    [Export] private Marker2D[] 拆分道具显示坐标;
    [Export] private Button[] 拆分道具取消按钮组;
    [Export] private PackedScene 拆分场景垂直容器;

    private List<string> 已选择的拆分道具 = [];

    public override void _Ready()
    {
        foreach (组件道具 项目 in 拆分道具组)
        {
            项目.信号被点击 += 置拆分道具垂直选择窗;
        }

        for (int i = 0; i < 拆分道具取消按钮组.Length; i++)
        {
            var 按钮 = 拆分道具取消按钮组[i];
            var 索引 = i;
            按钮.Pressed += () =>
            {
                拆分道具组[索引].清空组件();
                更新已选择的拆分道具();
            };
        }
        foreach (var 附加属性 in 附加属性标签)
        {
            附加属性.AddThemeColorOverride("font_color", new Color(配置.附加属性标签颜色));
        }
        重组按钮.Pressed += 重组按钮被点击;
        消耗标题标签.Text = $"消耗阴德: {配置.装备重组阴德消耗}    拥有: {游戏存档.玩家.基础属性.阴德}";
    }

    public void 初始化()
    {
        道具选项容器.清空选项();
        操作道具组件.清空组件();
        清空附加属性标签文本();
        foreach (var 道具 in 游戏存档.背包)
        {
            // 判断道具是否符合拆分条件
            if (道具.类型 == E道具类型.装备)
            {
                C装备模型 背包装备 = (C装备模型)道具;
                if (背包装备.附加属性.Count == 0)
                {
                    置选项组件属性(背包装备);
                }
            }
        }
    }

    private void 置拆分道具垂直选择窗(组件道具 道具组件)
    {
        // 判断是否已选择要重组的装备
        if (操作道具组件.取道具() == null)
        {
            游戏管理.日志实例.置关键字文本("待重组", "未选择", "的装备！", "red");
            return;
        }

        var 拆分组件数组 = 游戏管理.背包实例.取指定条件的道具组件列表
        (
            E道具索引.拆分石,
            E道具位置.装备重组,
            道具 =>
            {
                C装备模型 操作道具 = (C装备模型)操作道具组件.取道具();
                C装备模型 拆分道具 = (C装备模型)道具;
                return 拆分道具.已使用 &&
                拆分道具.部位 == 操作道具.部位 &&
                拆分道具.称谓要求 == 操作道具.称谓要求 &&
                已选择的拆分道具.IndexOf(道具.UUID) == -1;
            }
        );

        // 如果没有取到相关道具就不弹出弹窗
        if (拆分组件数组.Count == 0)
        {
            return;
        }

        int 道具实例索引 = -1;
        switch (道具组件.Name)
        {
            case "拆分道具一":
                道具实例索引 = 0;
                break;
            case "拆分道具二":
                道具实例索引 = 1;
                break;
            case "拆分道具三":
                道具实例索引 = 2;
                break;
            default:
                break;
        }

        if (道具实例索引 == -1)
        {
            return;
        }

        箭头垂直道具组 垂直场景 = 拆分场景垂直容器.Instantiate<箭头垂直道具组>();
        垂直场景.置道具(拆分组件数组);
        垂直场景.信号道具被点击 += (拆分道具) =>
        {
            // 将选择的已使用拆分道具添加到对应场景里
            var 道具 = 拆分道具.取道具();
            道具组件.置道具(道具, E道具位置.装备重组);
            更新已选择的拆分道具();
            var 父节点 = 垂直场景.GetParentOrNull<PopupPanel>();
            父节点?.QueueFree();
        };

        游戏管理.舞台实例.置弹窗(垂直场景, new((int)拆分道具显示坐标[道具实例索引].GlobalPosition.X, (int)拆分道具显示坐标[道具实例索引].GlobalPosition.Y));
    }

    private void 更新已选择的拆分道具()
    {
        // 更新已选择的拆分道具的UUID
        已选择的拆分道具 = [];
        清空附加属性标签文本();
        foreach (var 项目 in 拆分道具组)
        {
            var 项目道具 = (C装备模型)项目.取道具();
            if (项目道具 != null)
            {
                已选择的拆分道具.Add(项目道具.UUID);
                for (int i = 0; i < 附加属性标签.Length; i++)
                {
                    if (附加属性标签[i].Text == "")
                    {
                        置附加属性标签(附加属性标签[i], 项目道具.附加属性[0]);
                        break;
                    }
                }
            }
        }
    }

    private void 置选项组件属性(C装备模型 背包装备)
    {
        组件道具选项 道具选项实例 = 道具选项容器.创建选项实例();
        道具选项实例.道具组件.置道具(背包装备, E道具位置.装备重组);
        道具选项实例.标识一标签.Text = 背包装备.名称;
        道具选项实例.标识二标签.Text = 背包装备.称谓要求.ToString();
        道具选项实例.标识三标签.Text = 背包装备.部位.ToString();
        道具选项实例.信号被点击 += 道具组件 =>
        {
            操作道具组件.置道具(道具组件.取道具(), E道具位置.装备重组);
            操作道具标签.Text = 道具组件.取道具().名称;
            清空已选择的拆分道具();
        };
    }

    private void 清空已选择的拆分道具()
    {
        已选择的拆分道具 = [];
        清空附加属性标签文本();
        foreach (var 拆分道具 in 拆分道具组)
        {
            拆分道具.清空组件();
        }
    }

    private void 清空附加属性标签文本()
    {
        foreach (var 标签 in 附加属性标签)
        {
            标签.Text = "";
        }
    }

    private void 置附加属性标签(Label 附加属性标签, 结构.装备属性 装备属性)
    {
        附加属性标签.Text = 装备属性.属性名 + "：" + 装备属性.当前值 + " / " + 装备属性.上限值;
    }

    private void 重组按钮被点击()
    {
        // 从道具场景取出待拆分的道具模型
        C装备模型 重组装备 = (C装备模型)操作道具组件.取道具();
        if (重组装备 == null)
        {
            游戏管理.日志实例.置关键字文本("待重组", "未选择", "的装备！", "red");
            return;
        }

        // 判断是否选择了三个拆分道具
        if (已选择的拆分道具.Count != 3)
        {
            游戏管理.日志实例.置关键字文本(E道具索引.拆分石.ToString(), "所需要的", "数量不足！", "red");
            return;
        }

        // 判断玩家阴德是否充足
        if (游戏存档.玩家.基础属性.阴德 < 配置.装备重组阴德消耗)
        {
            游戏管理.日志实例.置关键字文本("阴德", "所需要的", "数量不足！", "red");
            return;
        }

        // 赋值重组装备的附加属性
        重组装备.附加属性 = [];
        foreach (var 道具组件 in 拆分道具组)
        {
            C装备模型 拆分道具 = (C装备模型)道具组件.取道具();
            重组装备.附加属性.Add(拆分道具.附加属性[0]);
            游戏管理.背包实例.删道具(拆分道具.UUID);
        }

        // 重置操作面板相关节点
        道具选项容器.删选项(重组装备.UUID);
        操作道具组件.清空组件();
        清空已选择的拆分道具();

        // 减去所需要的消耗
        游戏存档.玩家.基础属性.阴德 -= 配置.装备重组阴德消耗;

        // 更新UI
        消耗标题标签.Text = $"消耗阴德: {配置.装备重组阴德消耗}    拥有: {游戏存档.玩家.基础属性.阴德}";
        游戏管理.背包实例.刷新背包(游戏管理.背包实例.取选项卡索引());
        游戏管理.玩家实例.更新玩家基础属性();
    }
}
